Ce tutoriel a pour objectif d’expliquer ce qu’est un tuple en Python et comment l’utiliser efficacement. Vous apprendrez à créer, modifier et parcourir des tuples, tout en découvrant leurs avantages par rapport aux listes. L’objectif est de vous rendre autonome dans leur manipulation au quotidien.
Les tuples sont des structures de données fondamentales en Python qui permettent de stocker des collections ordonnées et immuables d'éléments. Ils sont largement utilisés pour regrouper des données liées de manière efficace et sécurisée.
Un tuple est une séquence ordonnée d'éléments qui ne peut pas être modifiée après sa création (immuable). Les tuples sont définis avec des parenthèses et peuvent contenir des éléments de types différents.
# Création de tuples de base # Tuple vide tuple_vide = () print(f"Tuple vide: {tuple_vide}") # Tuple avec des villes marocaines villes_maroc = ("Casablanca", "Rabat", "Marrakech", "Fès") print(f"Villes du Maroc: {villes_maroc}") # Tuple avec différents types de données informations_ville = ("Marrakech", 928850, 230, True) # nom, population, altitude, capitale régionale print(f"Informations sur Marrakech: {informations_ville}") # Tuple sans parenthèses (packing) coordonnees_maroc = 31.7917, -7.0926, "Afrique du Nord" print(f"Coordonnées géographiques: {coordonnees_maroc}") print(f"Type: {type(coordonnees_maroc)}") # Vérification du type print(f"villes_maroc est un tuple: {isinstance(villes_maroc, tuple)}")
Bien que les tuples et les listes semblent similaires, ils présentent des différences fondamentales qui déterminent leur utilisation appropriée dans différents contextes.
# Comparaison entre tuple et liste # DIFFÉRENCE 1: Mutabilité liste_villes = ["Tanger", "Tétouan", "Chefchaouen"] tuple_villes = ("Tanger", "Tétouan", "Chefchaouen") # Liste: modifiable liste_villes[0] = "Tanger-Med" # OK liste_villes.append("Asilah") # OK print(f"Liste modifiée: {liste_villes}") # Tuple: non modifiable # tuple_villes[0] = "Tanger-Med" # Erreur: TypeError # tuple_villes.append("Asilah") # Erreur: AttributeError # DIFFÉRENCE 2: Performance import sys print(f"\nTaille mémoire liste: {sys.getsizeof(liste_villes)} octets") print(f"Taille mémoire tuple: {sys.getsizeof(tuple_villes)} octets") # DIFFÉRENCE 3: Utilisation comme clés de dictionnaire coordonnees_casablanca = (33.5731, -7.5898) coordonnees_rabat = (34.0209, -6.8416) villes_geo = { coordonnees_casablanca: "Casablanca", coordonnees_rabat: "Rabat" } print(f"\nDictionnaire avec tuples comme clés: {villes_geo}") # DIFFÉRENCE 4: Méthodes disponibles print(f"\nMéthodes de liste: {[method for method in dir(liste_villes) if not method.startswith('_')]}") print(f"Méthodes de tuple: {[method for method in dir(tuple_villes) if not method.startswith('_')]}")
Le choix entre tuple et liste dépend du contexte d'utilisation. Voici les situations où les tuples sont particulièrement appropriés :
# CAS 1: Données immuables et constantes # Informations géographiques fixes du Maroc infos_maroc = ("Maroc", "Rabat", 446550, 37000000) # pays, capitale, superficie, population print(f"Informations fixes: {infos_maroc}") # CAS 2: Retour multiple de fonctions def calculer_statistiques(donnees): """Calcule plusieurs statistiques sur une liste de données""" moyenne = sum(donnees) / len(donnees) maximum = max(donnees) minimum = min(donnees) return moyenne, maximum, minimum # Retourne un tuple # Températures mensuelles à Marrakech temperatures = [12, 14, 17, 20, 24, 28, 32, 32, 28, 23, 17, 13] stats = calculer_statistiques(temperatures) print(f"\nStatistiques des températures: {stats}") print(f"Type du retour: {type(stats)}") # CAS 3: Clés de dictionnaire (car immuables) regions_maroc = { ("Casablanca", "Settat"): "Région Casablanca-Settat", ("Rabat", "Salé", "Kénitra"): "Région Rabat-Salé-Kénitra", ("Marrakech", "Safi"): "Région Marrakech-Safi" } print(f"\nRégions du Maroc: {regions_maroc}") # CAS 4: Sécurité des données class SystemeAuthentification: def __init__(self): # Tuple pour stocker les rôles fixes d'un utilisateur self.roles_utilisateur = ("lecture", "commentaire") def verifier_permissions(self): # Les rôles ne peuvent pas être modifiés accidentellement print(f"Rôles utilisateur: {self.roles_utilisateur}") auth = SystemeAuthentification() auth.verifier_permissions() # CAS 5: Données hétérogènes mais liées # Informations sur un produit marocain produit_marocain = ("Huile d'Argan", 150.0, "ML", True) # nom, prix, devise, disponible nom, prix, devise, disponible = produit_marocain # Déballage facile print(f"\nProduit: {nom}, Prix: {prix} {devise}, Disponible: {disponible}")
La création de tuples en Python suit des règles syntaxiques spécifiques qui permettent de définir des collections immuables de manière efficace et intuitive. Comprendre ces règles est essentiel pour utiliser correctement les tuples dans vos programmes.
Les tuples peuvent être créés vides ou contenir un ou plusieurs éléments. La syntaxe utilise principalement les parenthèses, mais il existe aussi des méthodes alternatives.
# Différentes méthodes pour créer des tuples # 1. Tuple vide tuple_vide = () print(f"Tuple vide: {tuple_vide}") print(f"Type: {type(tuple_vide)}") print(f"Taille: {len(tuple_vide)} éléments") # 2. Tuple avec plusieurs éléments (villes impériales du Maroc) villes_imperiales = ("Marrakech", "Fès", "Meknès", "Rabat") print(f"\nVilles impériales: {villes_imperiales}") print(f"Nombre de villes: {len(villes_imperiales)}") # 3. Tuple sans parenthèses (tuple packing) specialites_culinaires = "Tajine", "Couscous", "Pastilla", "Harira" print(f"\nSpécialités culinaires marocaines: {specialites_culinaires}") print(f"Type: {type(specialites_culinaires)}") # 4. Tuple avec différents types de données info_casablanca = ("Casablanca", 3.359, 1912, True) # ville, population (millions), année fondation, capitale économique print(f"\nInformations sur Casablanca: {info_casablanca}") print(f"Population: {info_casablanca[1]} millions") # 5. Tuple imbriqué (informations régionales) region_marrakech = ("Marrakech-Safi", 1394800, ("Marrakech", "Safi", "Essaouira")) print(f"\nRégion Marrakech-Safi: {region_marrakech}") print(f"Villes principales: {region_marrakech[2]}") # 6. Comparaison avec les listes liste_villes = ["Tanger", "Tétouan"] tuple_villes = ("Tanger", "Tétouan") print(f"\nListe: {liste_villes}, type: {type(liste_villes)}") print(f"Tuple: {tuple_villes}, type: {type(tuple_villes)}")
La création d'un tuple avec un seul élément nécessite une syntaxe particulière pour éviter la confusion avec une simple expression entre parenthèses. Il faut ajouter une virgule après l'élément.
# Syntaxe spéciale pour les tuples à un seul élément # ERREUR COURANTE : sans virgule, ce n'est pas un tuple pas_un_tuple = ("Casablanca") print(f"Sans virgule: {pas_un_tuple}") print(f"Type: {type(pas_un_tuple)}") # C'est une chaîne de caractères! # CORRECT : avec virgule, c'est bien un tuple mon_tuple = ("Casablanca",) print(f"\nAvec virgule: {mon_tuple}") print(f"Type: {type(mon_tuple)}") # Maintenant c'est un tuple print(f"Taille: {len(mon_tuple)} élément") # Exemples pratiques avec un seul élément capitale_maroc = ("Rabat",) plus_grande_ville = ("Casablanca",) ville_imperiale = ("Fès",) print(f"\nCapitale: {capitale_maroc}") print(f"Plus grande ville: {plus_grande_ville}") print(f"Ville impériale: {ville_imperiale}") # Tuple à un élément avec packing (sans parenthèses) ville_seule = "Marrakech", print(f"\nAvec packing: {ville_seule}") print(f"Type: {type(ville_seule)}") # Cas d'utilisation pratique : configuration unique config_site = ("https://www.visitmorocco.com",) langue_defaut = ("fr",) devise_nationale = ("MAD",) print(f"\nConfiguration site: {config_site}") print(f"Langue par défaut: {langue_defaut}") print(f"Devise: {devise_nationale}") # Vérification que c'est bien un tuple print(f"\nEst-ce un tuple? {isinstance(ville_seule, tuple)}") print(f"Est-ce un tuple? {isinstance(pas_un_tuple, tuple)}")
La fonction tuple() permet de convertir d'autres types de séquences en tuples. C'est particulièrement utile pour transformer des listes, des chaînes de caractères ou d'autres itérables en collections immuables.
# Conversion de différents types en tuples # 1. Conversion depuis une liste (cas le plus courant) liste_villes = ["Agadir", "Dakhla", "Laayoune"] tuple_villes_cotieres = tuple(liste_villes) print(f"Liste originale: {liste_villes}") print(f"Tuple converti: {tuple_villes_cotieres}") print(f"Type: {type(tuple_villes_cotieres)}") # 2. Conversion depuis une chaîne de caractères nom_maroc = "Maroc" tuple_lettres = tuple(nom_maroc) print(f"\nChaîne: '{nom_maroc}'") print(f"Tuple des lettres: {tuple_lettres}") # 3. Conversion depuis un range (générateur) codes_postaux = tuple(range(10000, 10006)) print(f"\nCodes postaux marocains: {codes_postaux}") # 4. Conversion depuis un dictionnaire (clés uniquement) regions_maroc = { "Casablanca-Settat": 6.8, "Rabat-Salé-Kénitra": 4.6, "Marrakech-Safi": 4.3 } tuple_regions = tuple(regions_maroc) print(f"\nDictionnaire des régions: {regions_maroc}") print(f"Tuple des noms de régions: {tuple_regions}") # 5. Conversion depuis un set (ensemble) plats_marocains = {"Tajine", "Couscous", "Pastilla", "Harira"} tuple_plats = tuple(plats_marocains) print(f"\nSet des plats: {plats_marocains}") print(f"Tuple des plats: {tuple_plats}") # 6. Cas pratique : sécuriser des données modifiables class SystemeConfiguration: def __init__(self): self.villes_configurables = ["Rabat", "Casablanca", "Marrakech"] def get_villes_fixes(self): # Retourne un tuple pour empêcher la modification return tuple(self.villes_configurables) config = SystemeConfiguration() villes_fixes = config.get_villes_fixes() print(f"\nVilles configurables (liste): {config.villes_configurables}") print(f"Villes fixes (tuple): {villes_fixes}") # 7. Conversion depuis un autre tuple (crée une copie) original = ("Fès", "Meknès") copie = tuple(original) print(f"\nTuple original: {original}") print(f"Copie du tuple: {copie}") print(f"Même objet? {original is copie}") # True car les tuples sont immuables # 8. Conversion depuis un générateur def generateur_monuments(): monuments = ["Hassan II", "Koutoubia", "Tour Hassan"] for monument in monuments: yield monument tuple_monuments = tuple(generateur_monuments()) print(f"\nMonuments marocains: {tuple_monuments}")
Bien que les tuples soient immuables, Python offre plusieurs méthodes pour accéder à leurs éléments et les manipuler de manière non destructive. Ces opérations permettent de lire et traiter les données sans modifier le tuple original.
L'accès par index permet de récupérer des éléments spécifiques d'un tuple en utilisant leur position. Les indices commencent à 0 pour le premier élément et supportent également les indices négatifs pour compter depuis la fin.
# Accès aux éléments par index avec des données marocaines # Tuple des villes impériales du Maroc villes_imperiales = ("Marrakech", "Fès", "Meknès", "Rabat") print(f"Villes impériales: {villes_imperiales}") # Accès par indices positifs (début à fin) print(f"\n--- Accès par indices positifs ---") print(f"Première ville (index 0): {villes_imperiales[0]}") print(f"Deuxième ville (index 1): {villes_imperiales[1]}") print(f"Troisième ville (index 2): {villes_imperiales[2]}") print(f"Quatrième ville (index 3): {villes_imperiales[3]}") # Accès par indices négatifs (fin à début) print(f"\n--- Accès par indices négatifs ---") print(f"Dernière ville (index -1): {villes_imperiales[-1]}") print(f"Avant-dernière ville (index -2): {villes_imperiales[-2]}") print(f"Deuxième depuis la fin (index -3): {villes_imperiales[-3]}") print(f"Première ville (index -4): {villes_imperiales[-4]}") # Tuple avec différents types de données (informations sur une ville) info_marrakech = ("Marrakech", 928850, 230, True, (31.63, -8.01)) # nom, population, altitude, capitale_regionnelle, coordonnees print(f"\n--- Accès dans un tuple hétérogène ---") print(f"Nom de la ville: {info_marrakech[0]}") print(f"Population: {info_marrakech[1]} habitants") print(f"Altitude: {info_marrakech[2]} mètres") print(f"Capitale régionale: {info_marrakech[3]}") print(f"Coordonnées GPS: {info_marrakech[4]}") # Gestion des erreurs d'index print(f"\n--- Gestion des erreurs ---") try: print(f"Index 10: {villes_imperiales[10]}") # IndexError except IndexError as e: print(f"Erreur: {e}") try: print(f"Index -10: {villes_imperiales[-10]}") # IndexError except IndexError as e: print(f"Erreur: {e}") # Vérification de la longueur avant accès index_souhaite = 2 if index_souhaite < len(villes_imperiales): print(f"\nVille à l'index {index_souhaite}: {villes_imperiales[index_souhaite]}") else: print(f"Index {index_souhaite} hors limites")
Le slicing permet d'extraire des sous-tuples en spécifiant une plage d'indices. La syntaxe tuple[début:fin:pas] offre une grande flexibilité pour travailler avec des portions de tuples.
# Slicing de tuples avec des données marocaines # Tuple des régions du Maroc regions_maroc = ( "Tanger-Tétouan-Al Hoceïma", "Oriental", "Fès-Meknès", "Rabat-Salé-Kénitra", "Béni Mellal-Khénifra", "Casablanca-Settat", "Marrakech-Safi", "Drâa-Tafilalet", "Souss-Massa", "Guelmim-Oued Noun", "Laâyoune-Sakia El Hamra", "Dakhla-Oued Ed-Dahab" ) print(f"Toutes les régions ({len(regions_maroc)}): {regions_maroc}") # Slicing de base [start:stop] print(f"\n--- Slicing de base ---") print(f"3 premières régions [0:3]: {regions_maroc[0:3]}") print(f"Régions du milieu [4:8]: {regions_maroc[4:8]}") print(f"4 dernières régions [-4:]: {regions_maroc[-4:]}") # Slicing avec step [start:stop:step] print(f"\n--- Slicing avec pas ---") print(f"Régions paires [::2]: {regions_maroc[::2]}") print(f"Régions impaires [1::2]: {regions_maroc[1::2]}") print(f"Toutes les 3 régions [::3]: {regions_maroc[::3]}") # Slicing avec indices négatifs print(f"\n--- Slicing avec indices négatifs ---") print(f"Exclure les 2 dernières [:-2]: {regions_maroc[:-2]}") print(f"De l'avant-dernière à la fin [-2:]: {regions_maroc[-2:]}") print(f"De -6 à -2 [-6:-2]: {regions_maroc[-6:-2]}") # Slicing pour inverser un tuple print(f"\n--- Inversion avec slicing ---") print(f"Régions inversées [::-1]: {regions_maroc[::-1]}") print(f"Inversé avec pas de 2 [::-2]: {regions_maroc[::-2]}") # Cas pratiques avec slicing print(f"\n--- Cas pratiques ---") # Extraire les régions du Nord regions_nord = regions_maroc[:4] print(f"Régions du Nord: {regions_nord}") # Extraire les régions du Sud regions_sud = regions_maroc[-4:] print(f"Régions du Sud: {regions_sud}") # Slicing avec des variables debut = 2 fin = 7 pas = 2 selection = regions_maroc[debut:fin:pas] print(f"Sélection [2:7:2]: {selection}") # Slicing qui retourne un tuple vide vide = regions_maroc[5:2] # start > stop sans pas négatif print(f"Slice vide [5:2]: {vide}") # Vérification que le slicing crée un nouveau tuple original = ("A", "B", "C") slice_result = original[0:2] print(f"\nOriginal: {original}, id: {id(original)}") print(f"Slice: {slice_result}, id: {id(slice_result)}") print(f"Même objet? {original is slice_result}")
Le parcours des tuples avec des boucles permet de traiter chaque élément séquentiellement. Python offre plusieurs méthodes pour itérer sur les tuples, adaptées à différents besoins.
# Parcours de tuples avec des données marocaines # Tuple des monuments historiques marocains monuments_maroc = ( "Mosquée Hassan II", "Koutoubia", "Médina de Fès", "Kasbah des Oudayas", "Chellah", "Médina de Marrakech" ) # 1. Boucle for simple print("=== Boucle for simple ===") for monument in monuments_maroc: print(f"- {monument}") # 2. Boucle avec enumerate() pour avoir l'index print(f"\n=== Boucle avec enumerate() ===") for index, monument in enumerate(monuments_maroc): print(f"{index + 1}. {monument}") # 3. Boucle avec enumerate() et début personnalisé print(f"\n=== Enumerate avec début personnalisé ===") for index, monument in enumerate(monuments_maroc, start=1): print(f"Monument #{index}: {monument}") # 4. Boucle avec range() et accès par index print(f"\n=== Boucle avec range() ===") for i in range(len(monuments_maroc)): print(f"Position {i}: {monuments_maroc[i]}") # 5. Boucle while avec index print(f"\n=== Boucle while ===") index = 0 while index < len(monuments_maroc): print(f"Monument {index + 1}: {monuments_maroc[index]}") index += 1 # 6. Parcours inversé print(f"\n=== Parcours inversé ===") for monument in reversed(monuments_maroc): print(f"- {monument}") # 7. Parcours avec condition print(f"\n=== Parcours avec condition ===") print("Monuments contenant 'Médina':") for monument in monuments_maroc: if "Médina" in monument: print(f"- {monument}") # 8. Parcours de tuple imbriqué print(f"\n=== Parcours de tuple imbriqué ===") villes_et_monuments = ( ("Casablanca", "Mosquée Hassan II"), ("Marrakech", "Koutoubia"), ("Fès", "Médina de Fès"), ("Rabat", "Kasbah des Oudayas") ) for ville, monument in villes_et_monuments: print(f"À {ville}, visitez: {monument}") # 9. Utilisation avec zip() pour parcourir plusieurs tuples print(f"\n=== Parcours avec zip() ===") villes = ("Casablanca", "Rabat", "Marrakech") populations = (3359000, 577827, 928850) regions = ("Casablanca-Settat", "Rabat-Salé-Kénitra", "Marrakech-Safi") print("Démographie des villes:") for ville, population, region in zip(villes, populations, regions): print(f"- {ville} ({region}): {population:,} habitants".replace(",", " ")) # 10. Parcours avec comprehension pour transformation print(f"\n=== Transformation avec comprehension ===") monuments_majuscules = tuple(monument.upper() for monument in monuments_maroc) print(f"Monuments en majuscules: {monuments_majuscules}") # 11. Utilisation dans une fonction def afficher_infos_ville(infos_ville): """Affiche les informations détaillées d'une ville""" nom, population, altitude, capitale = infos_ville statut = "Capitale régionale" if capitale else "Ville" print(f"{statut} {nom}: {population:,} habitants, {altitude}m d'altitude".replace(",", " ")) print(f"\n=== Utilisation dans une fonction ===") info_rabat = ("Rabat", 577827, 135, True) info_marrakech = ("Marrakech", 928850, 468, True) afficher_infos_ville(info_rabat) afficher_infos_ville(info_marrakech)
L'immuabilité est la caractéristique fondamentale des tuples qui les distingue des listes. Une fois créé, un tuple ne peut pas être modifié, ce qui garantit l'intégrité des données et offre des avantages en termes de performance et de sécurité.
L'immuabilité des tuples répond à des besoins spécifiques en programmation : sécurité des données, hachage pour les clés de dictionnaire, et optimisation mémoire. Cette caractéristique permet d'utiliser les tuples dans des contextes où la stabilité des données est cruciale.
# Démonstration de l'immuabilité des tuples # 1. Sécurité des données constantes # Informations géographiques fixes du Maroc infos_maroc_constantes = ("Maroc", "Rabat", "MAD", "+212") # pays, capitale, devise, indicatif print("Informations constantes sur le Maroc:") print(infos_maroc_constantes) # Tentative de modification (échouera) print(f"\nTentative de modification de la capitale...") try: infos_maroc_constantes[1] = "Casablanca" # TypeError except TypeError as e: print(f"Erreur: {e}") # 2. Hachage pour les clés de dictionnaire print(f"\n--- Utilisation comme clés de dictionnaire ---") # Coordonnées géographiques comme clés coordonnees_casa = (33.5731, -7.5898) coordonnees_rabat = (34.0209, -6.8416) villes_par_coordonnees = { coordonnees_casa: "Casablanca", coordonnees_rabat: "Rabat" } print(f"Dictionnaire avec tuples comme clés: {villes_par_coordonnees}") print(f"Ville aux coordonnées {coordonnees_casa}: {villes_par_coordonnees[coordonnees_casa]}") # Vérification du hachage print(f"\nHachage des tuples:") print(f"Hash de coordonnees_casa: {hash(coordonnees_casa)}") print(f"Hash de coordonnees_rabat: {hash(coordonnees_rabat)}") # 3. Performance et optimisation print(f"\n--- Performance ---") import sys import timeit villes_liste = ["Casablanca", "Rabat", "Marrakech", "Fès"] villes_tuple = ("Casablanca", "Rabat", "Marrakech", "Fès") print(f"Taille mémoire - Liste: {sys.getsizeof(villes_liste)} octets") print(f"Taille mémoire - Tuple: {sys.getsizeof(villes_tuple)} octets") # 4. Garantie d'intégrité dans les fonctions print(f"\n--- Intégrité des données ---") def traiter_donnees_geographiques(donnees): """Traite des données géographiques sans risque de modification accidentelle""" # Avec un tuple, on est sûr que les données n'ont pas changé ville, population, region = donnees return f"{ville} ({region}) - Population: {population} habitants" donnees_fixes = ("Agadir", 421844, "Souss-Massa") print(traiter_donnees_geographiques(donnees_fixes)) # 5. Utilisation dans les configurations print(f"\n--- Configurations système ---") class SystemeReservation: # Configuration immuable CONFIG_PAR_DEFAUT = ( 30, # jours_max_reservation 2, # reservations_simultanees "MAD", # devise True # confirmation_obligatoire ) def __init__(self): self.jours_max, self.reservations_max, self.devise, self.confirmation = self.CONFIG_PAR_DEFAUT def afficher_config(self): print(f"Configuration: {self.jours_max} jours max, {self.reservations_max} réservations max") reservation_system = SystemeReservation() reservation_system.afficher_config() print(f"Config originale protégée: {SystemeReservation.CONFIG_PAR_DEFAUT}")
L'immuabilité des tuples a des implications directes sur les opérations de modification et de suppression. Contrairement aux listes, on ne peut pas modifier, ajouter ou supprimer des éléments d'un tuple existant.
# Conséquences de l'immuabilité sur les opérations # Tuple des villes impériales du Maroc villes_imperiales = ("Marrakech", "Fès", "Meknès", "Rabat") print(f"Tuple original: {villes_imperiales}") # 1. IMPOSSIBLE: Modification directe d'un élément print(f"\n--- Tentatives de modification ---") try: villes_imperiales[0] = "Marrakech Ville" # Échouera except TypeError as e: print(f"Modification directe: {e}") # 2. IMPOSSIBLE: Ajout d'éléments try: villes_imperiales.append("Casablanca") # Échouera except AttributeError as e: print(f"Ajout d'élément: {e}") # 3. IMPOSSIBLE: Suppression d'éléments try: del villes_imperiales[1] # Échouera except TypeError as e: print(f"Suppression d'élément: {e}") # 4. IMPOSSIBLE: Méthodes de modification try: villes_imperiales.insert(1, "Tanger") # Échouera except AttributeError as e: print(f"Insertion: {e}") try: villes_imperiales.remove("Fès") # Échouera except AttributeError as e: print(f"Suppression par valeur: {e}") try: villes_imperiales.pop() # Échouera except AttributeError as e: print(f"Pop: {e}") try: villes_imperiales.sort() # Échouera except AttributeError as e: print(f"Tri: {e}") # 5. POSSIBLE: Réaffectation complète print(f"\n--- Réaffectation complète ---") print(f"Avant réaffectation: {villes_imperiales}") print(f"ID avant: {id(villes_imperiales)}") # On peut réaffecter la variable à un nouveau tuple villes_imperiales = ("Marrakech", "Fès", "Meknès", "Rabat", "Casablanca") print(f"Après réaffectation: {villes_imperiales}") print(f"ID après: {id(villes_imperiales)}") print(f"⚠️ Attention: Ce n'est pas une modification, c'est une nouvelle affectation!") # 6. POSSIBLE: Suppression complète du tuple print(f"\n--- Suppression complète ---") temp_tuple = ("Tanger", "Tétouan") print(f"Avant suppression: {temp_tuple}") del temp_tuple try: print(temp_tuple) # NameError except NameError: print("Tuple supprimé avec succès") # 7. Comparaison avec les listes print(f"\n--- Comparaison tuple vs liste ---") liste_villes = ["Marrakech", "Fès", "Meknès"] tuple_villes = ("Marrakech", "Fès", "Meknès") print(f"Liste originale: {liste_villes}") print(f"Tuple original: {tuple_villes}") # Liste: modifiable liste_villes[0] = "Marrakech Ville" liste_villes.append("Rabat") print(f"Liste modifiée: {liste_villes}") # Tuple: erreur si tentative de modification try: tuple_villes[0] = "Marrakech Ville" except TypeError: print(f"Tuple inchangé: {tuple_villes}") # 8. Impact sur les fonctions print(f"\n--- Impact sur le passage aux fonctions ---") def modifier_donnees(data): """Tente de modifier les données reçues""" print(f"Données reçues: {data}") try: data[0] = "MODIFIÉ" print(f"Modification réussie: {data}") except (TypeError, AttributeError): print("Impossible de modifier - données immuables") return data liste_test = ["Original", "Données"] tuple_test = ("Original", "Données") print("Avec liste:") resultat_liste = modifier_donnees(liste_test) print(f"Liste originale après fonction: {liste_test}") print("\nAvec tuple:") resultat_tuple = modifier_donnees(tuple_test) print(f"Tuple original après fonction: {tuple_test}")
Bien que les tuples soient immuables, il existe des techniques pour obtenir des versions modifiées d'un tuple. Ces méthodes créent de nouveaux tuples plutôt que de modifier l'original.
# Techniques pour modifier indirectement un tuple # Tuple original des villes marocaines villes_original = ("Casablanca", "Rabat", "Marrakech") print(f"Tuple original: {villes_original}") print(f"ID original: {id(villes_original)}") # 1. Conversion en liste, modification, reconversion en tuple print(f"\n--- Méthode liste/tuple ---") liste_temp = list(villes_original) liste_temp.append("Fès") # Ajout liste_temp[0] = "Casablanca Ville" # Modification villes_modifie = tuple(liste_temp) print(f"Tuple modifié: {villes_modifie}") print(f"ID modifié: {id(villes_modifie)}") print(f"Même objet? {villes_original is villes_modifie}") # 2. Concaténation pour ajouter des éléments print(f"\n--- Méthode concaténation ---") nouvelle_ville = ("Tanger",) villes_avec_tanger = villes_original + nouvelle_ville print(f"Ajout par concaténation: {villes_avec_tanger}") # Ajout de plusieurs villes villes_supplementaires = ("Agadir", "Oujda") villes_etendues = villes_original + villes_supplementaires print(f"Plusieurs ajouts: {villes_etendues}") # 3. Slicing pour "supprimer" des éléments print(f"\n--- Méthode slicing ---") # "Supprimer" le premier élément sans_premier = villes_original[1:] print(f"Sans premier élément: {sans_premier}") # "Supprimer" le dernier élément sans_dernier = villes_original[:-1] print(f"Sans dernier élément: {sans_dernier}") # "Supprimer" un élément au milieu index_a_supprimer = 1 sans_milieu = villes_original[:index_a_supprimer] + villes_original[index_a_supprimer+1:] print(f"Sans élément à l'index {index_a_supprimer}: {sans_milieu}") # 4. Remplacement d'éléments par slicing print(f"\n--- Remplacement par slicing ---") index_a_remplacer = 1 nouvelle_valeur = ("Rabat Capitale",) villes_remplace = villes_original[:index_a_remplacer] + nouvelle_valeur + villes_original[index_a_remplacer+1:] print(f"Après remplacement: {villes_remplace}") # 5. Utilisation de tuples imbriqués modifiables print(f"\n--- Tuples avec éléments modifiables ---") # Tuple contenant une liste (la liste reste modifiable) config_systeme = ( "Serveur Principal", "192.168.1.1", ["admin", "utilisateur"] # Liste modifiable ) print(f"Config originale: {config_systeme}") # On peut modifier la liste à l'intérieur du tuple config_systeme[2].append("invité") config_systeme[2][0] = "administrateur" print(f"Config modifiée: {config_systeme}") # 6. Fonction utilitaire pour les modifications complexes print(f"\n--- Fonctions utilitaires ---") def modifier_tuple(tuple_original, **modifications): """Crée un nouveau tuple avec les modifications spécifiées""" liste_temp = list(tuple_original) for index, valeur in modifications.items(): liste_temp[int(index)] = valeur return tuple(liste_temp) # Exemple d'utilisation infos_ville = ("Marrakech", 928850, "Marrakech-Safi") print(f"Avant modification: {infos_ville}") # Modifier la population et la région infos_modifiees = modifier_tuple(infos_ville, 1=1000000, 2="Région Marrakech") print(f"Après modification: {infos_modifiees}") # 7. Cas pratique: Gestion d'inventaire print(f"\n--- Cas pratique: Inventaire ---") class InventaireProduits: def __init__(self): # Tuple immuable pour les produits de base self.produits_base = ( ("ARG001", "Huile d'Argan", 150.0), ("THE001", "Thé Marocain", 45.0), ("TAP001", "Tapis Berbère", 1200.0) ) def ajouter_produit(self, code, nom, prix): "Ajoute un produit en créant un nouveau tuple" nouveau_produit = (code, nom, prix) self.produits_base = self.produits_base + (nouveau_produit,) def afficher_produits(self): print("Produits dans l'inventaire:") for produit in self.produits_base: print(f" - {produit[1]} ({produit[0]}): {produit[2]} DH") inventaire = InventaireProduits() inventaire.afficher_produits() print(f"\nAjout d'un nouveau produit...") inventaire.ajouter_produit("CER001", "Céramique de Fès", 350.0) inventaire.afficher_produits() print(f"\nID du tuple produits: {id(inventaire.produits_base)}")
Python offre diverses opérations et fonctions intégrées pour travailler efficacement avec les tuples. Ces outils permettent de combiner, rechercher et analyser les données contenues dans les tuples de manière optimale.
La concaténation permet de combiner plusieurs tuples en un seul, tandis que la répétition permet de créer un nouveau tuple en dupliquant le contenu d'un tuple existant. Ces opérations créent toujours de nouveaux tuples sans modifier les originaux.
# Opérations de concaténation et répétition sur les tuples # 1. Concaténation de base avec l'opérateur + villes_nord = ("Tanger", "Tétouan", "Chefchaouen") villes_sud = ("Agadir", "Dakhla", "Laayoune") villes_imperiales = ("Marrakech", "Fès", "Meknès") # Concaténation simple toutes_villes = villes_nord + villes_sud print(f"Villes du Nord + Sud: {toutes_villes}") # Concaténation multiple villes_completes = villes_nord + villes_imperiales + villes_sud print(f"Toutes les villes: {villes_completes}") # 2. Concaténation avec des tuples à un élément print(f"\n--- Concaténation avec tuples unitaires ---") capitale = ("Rabat",) villes_avec_capitale = villes_nord + capitale + villes_sud print(f"Avec capitale: {villes_avec_capitale}") # 3. Concaténation avec assignment print(f"\n--- Concaténation avec réaffectation ---") villes_actuelles = ("Casablanca", "Rabat") print(f"Avant: {villes_actuelles}") print(f"ID avant: {id(villes_actuelles)}") villes_actuelles = villes_actuelles + ("Marrakech", "Fès") print(f"Après: {villes_actuelles}") print(f"ID après: {id(villes_actuelles)}") print(f"⚠️ Nouveau tuple créé!") # 4. Répétition avec l'opérateur * print(f"\n--- Répétition de tuples ---") ville_unique = ("Casablanca",) villes_repetees = ville_unique * 5 print(f"Répétition 5 fois: {villes_repetees}") regions_principales = ("Casablanca-Settat", "Rabat-Salé-Kénitra") regions_etendues = regions_principales * 3 print(f"Régions répétées 3 fois: {regions_etendues}") # 5. Combinaison concaténation + répétition print(f"\n--- Combinaison d'opérations ---") villes_cotieres = ("Tanger", "Casablanca", "Agadir") separateur = ("---",) liste_presentation = (villes_cotieres + separateur) * 2 print(f"Liste de présentation: {liste_presentation}") # 6. Cas pratique: Génération de configurations print(f"\n--- Cas pratique: Configuration système ---") class SystemeReservation: JOURS_SEMAINE = ("Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi") def generer_calendrier_semaine(self, semaines=4): "Génère un calendrier pour plusieurs semaines" semaine_complete = self.JOURS_SEMAINE + ("Samedi", "Dimanche") calendrier = semaine_complete * semaines return calendrier def creer_creneaux_repetitifs(self, creneau_base, repetitions): "Crée des créneaux répétitifs" return creneau_base * repetitions reservation = SystemeReservation() calendrier_mois = reservation.generer_calendrier_semaine(4) print(f"Calendrier sur 4 semaines: {calendrier_mois}") print(f"Nombre de jours: {len(calendrier_mois)}") creneau_horaire = ("09:00-10:30",) creneaux_jour = reservation.creer_creneaux_repetitifs(creneau_horaire, 8) print(f"Créneaux horaires: {creneaux_jour}") # 7. Performance de la concaténation print(f"\n--- Performance et bonnes pratiques ---") # Méthode efficace pour de multiples concaténations tous_tuples = [ ("Maroc",), ("Algérie",), ("Tunisie",), ("Égypte",) ] # Méthode inefficace (création multiple de tuples) pays_afrique = () for pays in tous_tuples: pays_afrique = pays_afrique + pays # Crée un nouveau tuple à chaque itération print(f"Pays (méthode lente): {pays_afrique}") # Méthode efficace (une seule concaténation) pays_afrique_opti = tuple() for pays in tous_tuples: pays_afrique_opti += pays # Plus optimisé en interne print(f"Pays (méthode optimisée): {pays_afrique_opti}") # 8. Vérification de l'immuabilité print(f"\n--- Vérification d'immuabilité ---") original = (1, 2, 3) concatene = original + (4, 5) print(f"Original: {original}, ID: {id(original)}") print(f"Concaténé: {concatene}, ID: {id(concatene)}") print(f"Original inchangé: {original}")
L'opérateur in permet de vérifier rapidement si un élément est présent dans un tuple. Cette opération est très efficace et largement utilisée pour les tests de présence et les validations.
# Vérification de présence d'éléments dans les tuples # 1. Vérification basique avec 'in' villes_maroc = ("Casablanca", "Rabat", "Marrakech", "Fès", "Tanger") print("--- Tests de présence basiques ---") print(f"Villes disponibles: {villes_maroc}") print(f"'Casablanca' dans le tuple? {'Casablanca' in villes_maroc}") print(f"'Agadir' dans le tuple? {'Agadir' in villes_maroc}") print(f"'rabat' dans le tuple? {'rabat' in villes_maroc}") # Sensible à la casse # 2. Vérification avec 'not in' print(f"\n--- Tests d'absence ---") print(f"'Dakhla' pas dans le tuple? {'Dakhla' not in villes_maroc}") print(f"'Rabat' pas dans le tuple? {'Rabat' not in villes_maroc}") # 3. Utilisation dans des conditions print(f"\n--- Utilisation dans les conditions ---") def verifier_ville_imperiale(ville): villes_imperiales = ("Marrakech", "Fès", "Meknès", "Rabat") if ville in villes_imperiales: return f"{ville} est une ville impériale du Maroc" else: return f"{ville} n'est pas une ville impériale" print(verifier_ville_imperiale("Marrakech")) print(verifier_ville_imperiale("Casablanca")) # 4. Recherche dans des tuples imbriqués print(f"\n--- Recherche dans tuples imbriqués ---") regions_villes = ( ("Casablanca-Settat", "Casablanca", "Settat"), ("Rabat-Salé-Kénitra", "Rabat", "Salé", "Kénitra"), ("Marrakech-Safi", "Marrakech", "Safi") ) print(f"'Casablanca' dans les régions? {any('Casablanca' in region for region in regions_villes)}") print(f"'Agadir' dans les régions? {any('Agadir' in region for region in regions_villes)}") # 5. Recherche avec plusieurs conditions print(f"\n--- Recherche avec conditions multiples ---") class SystemeReservationVol: VILLES_DESSERVIES = ("Casablanca", "Marrakech", "Agadir", "Tanger", "Fès") def verifier_destination(self, ville_depart, ville_arrivee): if ville_depart not in self.VILLES_DESSERVIES: return f"Erreur: Départ de {ville_depart} non disponible" if ville_arrivee not in self.VILLES_DESSERVIES: return f"Erreur: Arrivée à {ville_arrivee} non disponible" if ville_depart == ville_arrivee: return "Erreur: Ville de départ et d'arrivée identiques" return f"Vol confirmé: {ville_depart} → {ville_arrivee}" reservation_vol = SystemeReservationVol() print(reservation_vol.verifier_destination("Casablanca", "Marrakech")) print(reservation_vol.verifier_destination("Casablanca", "Paris")) print(reservation_vol.verifier_destination("Rabat", "Marrakech")) # 6. Performance de la recherche print(f"\n--- Performance de la recherche ---") import time # Création d'un grand tuple grand_tuple = tuple(range(1000000)) # 1 million d'éléments # Recherche d'un élément au début debut = time.time() trouve_debut = 10 in grand_tuple temps_debut = time.time() - debut # Recherche d'un élément à la fin debut = time.time() trouve_fin = 999999 in grand_tuple temps_fin = time.time() - debut # Recherche d'un élément absent debut = time.time() trouve_absent = -1 in grand_tuple temps_absent = time.time() - debut print(f"Recherche au début: {temps_debut:.6f} secondes") print(f"Recherche à la fin: {temps_fin:.6f} secondes") print(f"Recherche absent: {temps_absent:.6f} secondes") print(f"⚠️ La recherche dans les tuples est séquentielle (O(n))") # 7. Cas pratique: Système d'authentification print(f"\n--- Cas pratique: Authentification ---") class SystemeAuthentification: # Utilisateurs autorisés (tuple pour immutabilité) UTILISATEURS_AUTORISES = ( ("admin", "admin123"), ("karim", "pass123"), ("fatima", "secret456") ) def authentifier(self, username, password): credentials = (username, password) return credentials in self.UTILISATEURS_AUTORISES auth = SystemeAuthentification() print(f"Authentification admin: {auth.authentifier('admin', 'admin123')}") print(f"Authentification invalide: {auth.authentifier('admin', 'wrongpass')}") print(f"Authentification karim: {auth.authentifier('karim', 'pass123')}")
Python fournit plusieurs fonctions intégrées qui fonctionnent avec les tuples pour obtenir des informations statistiques et mesurer leurs caractéristiques. Ces fonctions sont optimisées et très efficaces.
# Fonctions intégrées pour l'analyse des tuples # 1. len() - Longueur d'un tuple print("--- Fonction len() ---") villes_maroc = ("Casablanca", "Rabat", "Marrakech", "Fès", "Tanger", "Agadir") populations = (3359000, 577827, 928850, 1112072, 947952, 421844) print(f"Nombre de villes: {len(villes_maroc)}") print(f"Nombre de populations: {len(populations)}") print(f"Tuple vide: {len(())}") print(f"Tuple à un élément: {len(('Rabat',))}") # 2. min() et max() - Valeurs extrêmes print(f"\n--- Fonctions min() et max() ---") temperatures = (32, 28, 35, 40, 25, 38) altitudes = (12, 135, 468, 410, 580, 23) print(f"Températures: {temperatures}") print(f"Température minimale: {min(temperatures)}°C") print(f"Température maximale: {max(temperatures)}°C") print(f"Altitude minimale: {min(altitudes)}m") print(f"Altitude maximale: {max(altitudes)}m") # min() et max() avec des chaînes print(f"\nVilles: {villes_maroc}") print(f"Ville première alphabétiquement: {min(villes_maroc)}") print(f"Ville dernière alphabétiquement: {max(villes_maroc)}") # 3. sum() - Somme des éléments print(f"\n--- Fonction sum() ---") print(f"Populations: {populations}") print(f"Population totale: {sum(populations):,} habitants".replace(",", " ")) print(f"Somme des températures: {sum(temperatures)}") print(f"Moyenne des températures: {sum(temperatures) / len(temperatures):.1f}°C") # 4. Combinaison de fonctions print(f"\n--- Combinaison de fonctions ---") def analyser_donnees(donnees): "Analyse complète d'un tuple de données numériques" if not donnees: return "Aucune donnée à analyser" minimum = min(donnees) maximum = max(donnees) total = sum(donnees) moyenne = total / len(donnees) etendue = maximum - minimum return { "min": minimum, "max": maximum, "total": total, "moyenne": moyenne, "étendue": etendue, "nombre": len(donnees) } revenus_trimestriels = (1250000, 980000, 1560000, 1420000) analyse = analyser_donnees(revenus_trimestriels) print(f"Revenus trimestriels: {revenus_trimestriels}") for cle, valeur in analyse.items(): print(f" {cle}: {valeur:,.0f} DH".replace(",", " ")) # 5. Gestion des erreurs print(f"\n--- Gestion des erreurs ---") # Tuple vide try: print(min(())) except ValueError as e: print(f"Erreur min() sur tuple vide: {e}") try: print(max(())) except ValueError as e: print(f"Erreur max() sur tuple vide: {e}") print(f"Somme tuple vide: {sum(())}") # Retourne 0 print(f"Longueur tuple vide: {len(())}") # Retourne 0 # Types incompatibles mixte = (1, "deux", 3.0) try: print(min(mixte)) except TypeError as e: print(f"Erreur types incompatibles: {e}") # 6. Cas pratique: Système de statistiques print(f"\n--- Cas pratique: Statistiques touristiques ---") class StatistiquesTourisme: def __init__(self): self.visiteurs_mensuels = () def ajouter_mois(self, visiteurs): self.visiteurs_mensuels += (visiteurs,) def generer_rapport(self): if not self.visiteurs_mensuels: return "Aucune donnée disponible" total_visiteurs = sum(self.visiteurs_mensuels) moyenne_mensuelle = total_visiteurs / len(self.visiteurs_mensuels) mois_plus_visite = max(self.visiteurs_mensuels) mois_moins_visite = min(self.visiteurs_mensuels) return ( f"Rapport sur {len(self.visiteurs_mensuels)} mois:\n" f" Total visiteurs: {total_visiteurs:,}\n".replace(",", " ") + f" Moyenne mensuelle: {moyenne_mensuelle:,.0f}\n".replace(",", " ") + f" Meilleur mois: {mois_plus_visite:,} visiteurs\n".replace(",", " ") + f" Mois le plus calme: {mois_moins_visite:,} visiteurs".replace(",", " ") ) stats = StatistiquesTourisme() stats.ajouter_mois(125000) stats.ajouter_mois(98000) stats.ajouter_mois(156000) stats.ajouter_mois(142000) stats.ajouter_mois(110000) print(stats.generer_rapport()) # 7. Performance des fonctions intégrées print(f"\n--- Performance ---") import time # Grand tuple de données grandes_donnees = tuple(range(1, 1000001)) # 1 million de nombres debut = time.time() longueur = len(grandes_donnees) temps_len = time.time() - debut debut = time.time() minimum = min(grandes_donnees) temps_min = time.time() - debut debut = time.time() maximum = max(grandes_donnees) temps_max = time.time() - debut debut = time.time() somme = sum(grandes_donnees) temps_sum = time.time() - debut print(f"Performance sur 1 million d'éléments:") print(f" len(): {temps_len:.6f}s") print(f" min(): {temps_min:.6f}s") print(f" max(): {temps_max:.6f}s") print(f" sum(): {temps_sum:.6f}s") print(f" Résultats - Longueur: {longueur}, Min: {minimum}, Max: {maximum}, Somme: {somme:,}".replace(",", " "))
Le déballage (unpacking) est une fonctionnalité puissante de Python qui permet d'assigner les éléments d'un tuple à des variables individuelles en une seule opération. Cette technique rend le code plus lisible et concis.
L'affectation multiple permet d'assigner les éléments d'un tuple à plusieurs variables en une seule ligne. C'est l'une des utilisations les plus courantes et pratiques du déballage des tuples.
# Affectation multiple avec déballage de tuples # 1. Déballage basique print("--- Déballage basique ---") coordonnees_marrakech = (31.6295, -7.9811) latitude, longitude = coordonnees_marrakech print(f"Coordonnées de Marrakech: latitude={latitude}, longitude={longitude}") # 2. Déballage avec informations ville infos_casablanca = ("Casablanca", 3359000, "Casablanca-Settat") nom, population, region = infos_casablanca print(f"\n{nom} - Population: {population:,} - Région: {region}".replace(",", " ")) # 3. Échange de valeurs sans variable temporaire print(f"\n--- Échange de valeurs ---") ville_a, ville_b = "Rabat", "Casablanca" print(f"Avant échange: ville_a={ville_a}, ville_b={ville_b}") # Échange élégant avec tuple unpacking ville_a, ville_b = ville_b, ville_a print(f"Après échange: ville_a={ville_a}, ville_b={ville_b}") # 4. Déballage depuis le retour d'une fonction print(f"\n--- Déballage depuis fonction ---") def obtenir_infos_ville(ville): "Retourne les informations d'une ville sous forme de tuple" infos = { "Rabat": ("Rabat", 577827, "Capitale", 135), "Marrakech": ("Marrakech", 928850, "Ville Impériale", 468), "Fès": ("Fès", 1112072, "Ville Impériale", 410) } return infos.get(ville, ("Inconnue", 0, "Inconnue", 0)) # Déballage direct du retour de fonction nom_ville, population, type_ville, altitude = obtenir_infos_ville("Marrakech") print(f"{nom_ville} - {population} habitants - {type_ville} - Altitude: {altitude}m") # 5. Déballage dans les boucles print(f"\n--- Déballage dans les boucles ---") villes_infos = [ ("Casablanca", 3359000, "Économique"), ("Rabat", 577827, "Politique"), ("Marrakech", 928850, "Touristique") ] print("Villes du Maroc:") for nom, population, role in villes_infos: print(f" - {nom}: {population:,} habitants (Rôle: {role})".replace(",", " ")) # 6. Déballage avec des tuples imbriqués print(f"\n--- Déballage de tuples imbriqués ---") ville_complete = ("Fès", 1112072, (34.0333, -5.0000)) nom_ville, population, (lat, lon) = ville_complete print(f"{nom_ville} - Population: {population} - GPS: ({lat}, {lon})") # 7. Cas pratique: Système de coordonnées print(f"\n--- Cas pratique: Gestion de coordonnées ---") class SystemeGeographique: def __init__(self): self.villes = { "Casablanca": (33.5731, -7.5898, "Côte Atlantique"), "Marrakech": (31.6295, -7.9811, "Plaine du Haouz"), "Fès": (34.0333, -5.0000, "Plateau du Saïss") } def afficher_localisation(self, ville): if ville in self.villes: latitude, longitude, region = self.villes[ville] print(f"{ville} - Région: {region}") print(f" Coordonnées: {latitude}°N, {longitude}°W") else: print(f"Ville {ville} non trouvée") geo = SystemeGeographique() geo.afficher_localisation("Marrakech") geo.afficher_localisation("Casablanca") # 8. Gestion des erreurs print(f"\n--- Gestion des erreurs de déballage ---") # Erreur: trop de valeurs à déballer try: a, b = (1, 2, 3) except ValueError as e: print(f"Erreur de déballage: {e}") # Erreur: pas assez de valeurs try: x, y, z = (10, 20) except ValueError as e: print(f"Erreur de déballage: {e}") # Vérification avant déballage donnees = ("Rabat", 577827) if len(donnees) == 3: ville, pop, region = donnees else: print("Structure de données invalide pour le déballage")
Il est souvent utile d'ignorer certaines valeurs lors du déballage. Python permet cela en utilisant le caractère underscore _ comme variable "poubelle" pour les valeurs non souhaitées.
# Ignorer des valeurs lors du déballage de tuples # 1. Utilisation de _ pour ignorer des valeurs print("--- Ignorer avec _ ---") # Tuple avec plusieurs informations infos_vol = ("CMN", "RAK", "AT800", "2024-01-15", "10:30", "12:00") # aéroport_départ, aéroport_arrivée, numéro_vol, date, heure_départ, heure_arrivée # On ne veut que les aéroports et la date depart, arrivee, _, date, _, _ = infos_vol print(f"Vol de {depart} à {arrivee} le {date}") # 2. Ignorer plusieurs valeurs consécutives print(f"\n--- Ignorer plusieurs valeurs ---") donnees_capteur = (25.5, 65.2, 1013.2, 2.1, 45.6, "OK") # température, humidité, pression, vitesse_vent, radiation, statut # Seulement température et statut temperature, *_, statut = donnees_capteur print(f"Température: {temperature}°C, Statut: {statut}") # 3. Ignorer des valeurs dans les boucles print(f"\n--- Ignorer dans les boucles ---") resultats_examen = [ ("Ahmed", "Math", 16.5, "2024-01-10"), ("Fatima", "Physique", 18.0, "2024-01-11"), ("Karim", "Chimie", 14.5, "2024-01-12") ] print("Résultats des étudiants:") for nom, _, note, _ in resultats_examen: print(f" - {nom}: {note}/20") # 4. Ignorer le premier ou dernier élément print(f"\n--- Ignorer premier/dernier ---") serie_temperatures = (22.1, 23.5, 24.8, 25.3, 24.9, 23.7) # Ignorer le premier élément (capteur défaillant) _, *temperatures_valides = serie_temperatures print(f"Températures valides: {temperatures_valides}") # Ignorer le dernier élément (mesure incomplète) *temperatures_completes, _ = serie_temperatures print(f"Températures complètes: {temperatures_completes}") # 5. Cas pratique: Traitement de données météo print(f"\n--- Cas pratique: Données météorologiques ---") class AnalyseMeteo: def __init__(self): self.donnees_brutes = [] def ajouter_releve(self, releve): "Ajoute un relevé météo (timestamp, temp, humidité, pression, vent, station)" self.donnees_brutes.append(releve) def extraire_temperatures(self): "Extrait seulement les températures en ignorant les autres données" temperatures = [] for timestamp, temperature, *_ in self.donnees_brutes: temperatures.append(temperature) return temperatures def analyser_tendances(self): "Analyse les tendances en ignorant les données de station" if not self.donnees_brutes: return "Aucune donnée" *_, (dernier_ts, derniere_temp, _, _, _, _) = self.donnees_brutes premier_ts, premiere_temp, *_ = self.donnees_brutes[0] evolution = derniere_temp - premiere_temp return f"Évolution: {evolution:+.1f}°C de {premier_ts} à {dernier_ts}" meteo = AnalyseMeteo() meteo.ajouter_releve(("2024-01-15 08:00", 18.5, 65, 1015, 12, "Casablanca")) meteo.ajouter_releve(("2024-01-15 12:00", 24.2, 55, 1013, 8, "Casablanca")) meteo.ajouter_releve(("2024-01-15 16:00", 22.8, 60, 1014, 15, "Casablanca")) print(f"Températures: {meteo.extraire_temperatures()}") print(meteo.analyser_tendances()) # 6. Ignorer dans les fonctions print(f"\n--- Ignorer dans les fonctions ---") def traiter_commande(donnees_commande): "Traite une commande en ignorant certaines métadonnées" # Format: (id_commande, client, produit, quantite, prix, date, statut_livraison) _, client, produit, quantite, prix, _, _ = donnees_commande total = quantite * prix return f"Commande {client}: {quantite}x {produit} = {total} DH" commande = (1001, "Restaurant Marrakech", "Huile d'Argan", 5, 150.0, "2024-01-15", "en cours") print(traiter_commande(commande)) # 7. Bonnes pratiques print(f"\n--- Bonnes pratiques ---") # Utiliser _ pour les valeurs vraiment ignorées ville, _, region = ("Tanger", 947952, "Tanger-Tétouan-Al Hoceïma") print(f"{ville} - {region}") # Éviter d'utiliser _ comme variable normale # _ = "valeur temporaire" # À éviter # print(_) # Risque de confusion # Utilisation correcte dans les compréhensions villes_complexes = [ ("Casablanca", 3359000, "économique", 33.5731, -7.5898), ("Marrakech", 928850, "touristique", 31.6295, -7.9811) ] # Extraire seulement noms et rôles noms_roles = [(nom, role) for nom, _, role, *_ in villes_complexes] print(f"Noms et rôles: {noms_roles}")
L'opérateur * permet de capturer plusieurs éléments lors du déballage. Cette fonctionnalité est extrêmement utile pour travailler avec des tuples de taille variable ou pour séparer les éléments en groupes.
# Utilisation de * pour capturer plusieurs éléments # 1. Capture basique avec * print("--- Capture basique avec * ---") villes_maroc = ("Casablanca", "Rabat", "Marrakech", "Fès", "Tanger", "Agadir") # Première ville et le reste premiere, *reste = villes_maroc print(f"Première ville: {premiere}") print(f"Autres villes: {reste}") # Première, dernière, et celles du milieu premiere, *milieu, derniere = villes_maroc print(f"\nPremière: {premiere}, Dernière: {derniere}") print(f"Villes du milieu: {milieu}") # 2. Capture à différentes positions print(f"\n--- Capture à différentes positions ---") donnees_meteo = ("Casablanca", 25.5, 65, 1013, 15, "ensoleillé", "2024-01-15") # Capture au début *meteo, date = donnees_meteo print(f"Données météo: {meteo}") print(f"Date: {date}") # Capture au milieu ville, temperature, *details, conditions, date = donnees_meteo print(f"\nVille: {ville}, Température: {temperature}°C") print(f"Détails: {details}") print(f"Conditions: {conditions}, Date: {date}") # 3. Capture dans les boucles print(f"\n--- Capture dans les boucles ---") voyages = [ ("Casablanca", "Marrakech", "Fès", "Tanger"), ("Rabat", "Meknès"), ("Agadir", "Essaouira", "Safi"), ("Tanger",) ] print("Itinéraires de voyage:") for premiere, *autres in voyages: if autres: print(f" Départ de {premiere}, puis: {', '.join(autres)}") else: print(f" Séjour à {premiere}") # 4. Capture multiple avec * print(f"\n--- Capture multiple ---") classements = ("Raja CA", "Wydad AC", "FAR", "MAS", "OCS", "HUSA", "RCA") # Premier, les 3 suivants, et le reste premier, *suivants, *reste = classements # Erreur: multiple * # Correct: un seul * par déballage premier, deuxieme, troisieme, *reste = classements print(f"Podium: 1.{premier}, 2.{deuxieme}, 3.{troisieme}") print(f"Autres équipes: {reste}") # 5. Cas pratique: Système de réservation print(f"\n--- Cas pratique: Système de réservation ---") class GestionnaireReservations: def __init__(self): self.reservations = [] def ajouter_reservation(self, *infos_reservation): "Ajoute une réservation (client, *passagers, hotel, dates)" self.reservations.append(infos_reservation) def lister_reservations(self): print("Réservations en cours:") for i, reservation in enumerate(self.reservations, 1): client, *passagers, hotel, dates = reservation print(f" {i}. Client: {client}") if passagers: print(f" Passagers: {', '.join(passagers)}") print(f" Hôtel: {hotel}, Dates: {dates}") def statistiques_passagers(self): "Calcule les statistiques sur les passagers" total_passagers = 0 reservations_avec_passagers = 0 for reservation in self.reservations: _, *passagers, _, _ = reservation total_passagers += len(passagers) if passagers: reservations_avec_passagers += 1 return { "total_passagers": total_passagers, "reservations_avec_passagers": reservations_avec_passagers, "total_reservations": len(self.reservations) } reservations = GestionnaireReservations() reservations.ajouter_reservation("Ahmed Alami", "Fatima Alami", "La Mamounia", "2024-03-15/2024-03-20") reservations.ajouter_reservation("Karim Bennani", "Sofia Bennani", "Yasmine Bennani", "Royal Mansour", "2024-04-01/2024-04-07") reservations.ajouter_reservation("Leila Cherkaoui", "Hotel Hassan", "2024-02-10/2024-02-12") reservations.lister_reservations() stats = reservations.statistiques_passagers() print(f"\nStatistiques: {stats}") # 6. Capture avec des valeurs par défaut print(f"\n--- Capture avec valeurs par défaut ---") def traiter_commandes(*commandes): "Traite des commandes de longueur variable" print("Commandes à traiter:") for commande in commandes: # Format: (produit, quantite, *options) produit, quantite, *options = commande urgente = "URGENT" if "urgent" in options else "normal" emballage = options[1] if len(options) > 1 else "standard" print(f" - {produit} x{quantite} ({urgente}, emballage: {emballage})") commandes_variées = [ ("Huile d'Argan", 2), ("Tapis Berbère", 1, "urgent"), ("Thé Marocain", 5, "normal", "cadeau"), ("Poterie de Fès", 3, "urgent", "renforcé") ] traiter_commandes(*commandes_variées) # 7. Capture avancée avec conditions print(f"\n--- Capture avancée avec conditions ---") resultats_concours = [ ("Ahmed", 18.5, 16.0, 17.5, 19.0), ("Fatima", 20.0, 19.5, 18.0), ("Karim", 15.5, 16.5, 14.0, 17.0, 16.0), ("Sofia", 19.0, 18.5) ] print("Résultats du concours (meilleure et pire note ignorées):") for participant, meilleure, *notes_intermediaires, pire in resultats_concours: moyenne_intermediaire = sum(notes_intermediaires) / len(notes_intermediaires) if notes_intermediaires else 0 print(f" {participant}: moyenne intermédiaire = {moyenne_intermediaire:.2f}") # 8. Combinaison avec d'autres techniques print(f"\n--- Combinaison de techniques ---") donnees_complexes = [ ("Casablanca", 3359000, "économique", 33.5731, -7.5898, "port", "mosquée"), ("Marrakech", 928850, "touristique", 31.6295, -7.9811, "place", "jardin", "souk"), ("Fès", 1112072, "culturel", 34.0333, -5.0000) ] print("Informations essentielles des villes:") for ville, population, type_ville, *_, *attractions in donnees_complexes: attractions_text = ", ".join(attractions) if attractions else "aucune" print(f" {ville} ({type_ville}): {attractions_text}")
Les tuples peuvent contenir d'autres tuples, créant ainsi des structures de données complexes et hiérarchiques. Cette fonctionnalité est particulièrement utile pour représenter des données multidimensionnelles comme des coordonnées, des matrices ou des structures arborescentes.
L'accès aux éléments dans des tuples imbriqués se fait en chaînant les indices. Chaque niveau d'imbrication nécessite un indice supplémentaire pour atteindre l'élément souhaité.
# Accès aux éléments dans des tuples imbriqués # 1. Structure basique de tuple imbriqué print("--- Structure basique ---") # Coordonnées GPS de villes marocaines coordonnees_ville = ((31.6295, -7.9811), "Marrakech", "Marrakech-Safi") print(f"Tuple complet: {coordonnees_ville}") print(f"Type: {type(coordonnees_ville)}") print(f"Coordonnées GPS: {coordonnees_ville[0]}") print(f"Type des coordonnées: {type(coordonnees_ville[0])}") print(f"Latitude: {coordonnees_ville[0][0]}") print(f"Longitude: {coordonnees_ville[0][1]}") print(f"Nom de la ville: {coordonnees_ville[1]}") print(f"Région: {coordonnees_ville[2]}") # 2. Tuple de tuples (matrice 2D) print(f"\n--- Tuple de tuples (matrice) ---") # Distances entre villes marocaines (en km) distances_villes = ( (0, 86, 240, 530, 330), # De Casablanca (86, 0, 320, 590, 400), # De Rabat (240, 320, 0, 470, 170), # De Marrakech (530, 590, 470, 0, 640), # De Fès (330, 400, 170, 640, 0) # De Agadir ) villes = ["Casablanca", "Rabat", "Marrakech", "Fès", "Agadir"] print("Matrice des distances:") for i in range(len(distances_villes)): for j in range(len(distances_villes[i])): if i != j: print(f" {villes[i]} → {villes[j]}: {distances_villes[i][j]} km") # 3. Accès avec déballage multiple print(f"\n--- Accès avec déballage ---") # Informations détaillées sur une ville ville_complete = ("Fès", 1112072, (34.0333, -5.0000), ("Médina", "Université Al Quaraouiyine")) # Déballage multiple nom, population, (latitude, longitude), (attraction1, attraction2) = ville_complete print(f"Ville: {nom}") print(f"Population: {population:,}".replace(",", " ")) print(f"Coordonnées: ({latitude}, {longitude})") print(f"Attractions: {attraction1}, {attraction2}") # 4. Structure hiérarchique complexe print(f"\n--- Structure hiérarchique ---") # Régions du Maroc avec leurs villes principales regions_maroc = ( ("Casablanca-Settat", (("Casablanca", 3359000), ("Settat", 142250))), ("Rabat-Salé-Kénitra", (("Rabat", 577827), ("Salé", 890403), ("Kénitra", 431282))), ("Marrakech-Safi", (("Marrakech", 928850), ("Safi", 308508))) ) print("Structure régionale du Maroc:") for region in regions_maroc: nom_region, villes_region = region print(f"\nRégion: {nom_region}") for ville, population in villes_region: print(f" - {ville}: {population:,} habitants".replace(",", " ")) # 5. Accès profond avec indices multiples print(f"\n--- Accès profond ---") print(f"Première région: {regions_maroc[0][0]}") print(f"Première ville de la première région: {regions_maroc[0][1][0][0]}") print(f"Population de Casablanca: {regions_maroc[0][1][0][1]:,}".replace(",", " ")) # 6. Parcours récursif des tuples imbriqués print(f"\n--- Parcours récursif ---") def parcourir_tuples(structure, niveau=0): "Parcourt récursivement une structure de tuples imbriqués" indent = " " * niveau if isinstance(structure, tuple): if structure and isinstance(structure[0], tuple): print(f"{indent}Tuple de tuples (niveau {niveau}):") for item in structure: parcourir_tuples(item, niveau + 1) else: print(f"{indent}Tuple: {structure}") else: print(f"{indent}Valeur: {structure}") exemple_complexe = (("A", "B"), (("C", "D"), "E"), "F") print("Structure complexe:") parcourir_tuples(exemple_complexe) # 7. Modification indirecte via conversion print(f"\n--- Modification indirecte ---") # Conversion en listes pour modification structure_modifiable = [list(region) for region in regions_maroc] for region in structure_modifiable: region[1] = [list(ville) for ville in region[1]] # Modification structure_modifiable[0][1][0][1] = 3400000 # Nouvelle population pour Casablanca # Reconversion en tuples regions_modifiees = tuple( (nom_region, tuple(tuple(ville) for ville in villes)) for nom_region, villes in structure_modifiable ) print(f"Population Casablanca modifiée: {regions_modifiees[0][1][0][1]:,}".replace(",", " "))
Les tuples imbriqués sont particulièrement utiles dans des scénarios réels comme les systèmes de coordonnées, les configurations complexes, les structures de données hiérarchiques et les jeux de données multidimensionnels.
# Cas d'usage pratiques des tuples imbriqués # 1. Système de coordonnées géographiques print("--- Système géographique ---") class SystemeGeographique: def __init__(self): # (ville, (latitude, longitude), altitude, population) self.villes = ( ("Casablanca", (33.5731, -7.5898), 12, 3359000), ("Marrakech", (31.6295, -7.9811), 468, 928850), ("Fès", (34.0333, -5.0000), 410, 1112072), ("Tanger", (35.7595, -5.8340), 80, 947952) ) def trouver_ville_plus_peuplee(self): "Retourne la ville la plus peuplée" ville_max = None population_max = -1 for ville, coords, altitude, population in self.villes: if population > population_max: population_max = population ville_max = ville return ville_max, population_max def calculer_distance(self, ville1, ville2): "Calcule la distance approximative entre deux villes" from math import radians, sin, cos, sqrt, atan2 # Trouver les coordonnées coords1 = coords2 = None for ville, coords, _, _ in self.villes: if ville == ville1: coords1 = coords if ville == ville2: coords2 = coords if coords1 and coords2: lat1, lon1 = radians(coords1[0]), radians(coords1[1]) lat2, lon2 = radians(coords2[0]), radians(coords2[1]) # Formule de Haversine dlat, dlon = lat2 - lat1, lon2 - lon1 a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2 c = 2 * atan2(sqrt(a), sqrt(1-a)) distance = 6371 * c # Rayon de la Terre en km return round(distance, 1) return None geo = SystemeGeographique() ville_peuplee, population = geo.trouver_ville_plus_peuplee() print(f"Ville la plus peuplée: {ville_peuplee} ({population:,} habitants)".replace(",", " ")) distance = geo.calculer_distance("Casablanca", "Marrakech") print(f"Distance Casablanca-Marrakech: {distance} km") # 2. Système de réservation hôtelière print(f"\n--- Système de réservation ---") class SystemeReservation: def __init__(self): # (hôtel, ville, (prix_min, prix_max), (équipements)) self.hotels = ( ("La Mamounia", "Marrakech", (2500, 8000), ("piscine", "spa", "golf")), ("Hotel Hassan", "Rabat", (800, 2000), ("wifi", "parking")), ("Sofitel", "Casablanca", (1200, 3500), ("piscine", "business")), ("Riad Fès", "Fès", (600, 1500), ("jardin", "terrasse")) ) def rechercher_par_ville(self, ville): "Recherche les hôtels dans une ville spécifique" resultats = [] for hotel, hotel_ville, prix, equipements in self.hotels: if hotel_ville.lower() == ville.lower(): resultats.append((hotel, prix, equipements)) return resultats def rechercher_par_budget(self, budget_max): "Recherche les hôtels dans un budget donné" resultats = [] for hotel, ville, (prix_min, prix_max), equipements in self.hotels: if prix_min <= budget_max: resultats.append((hotel, ville, prix_min, equipements)) return resultats def rechercher_avec_equipement(self, equipement): "Recherche les hôtels avec un équipement spécifique" resultats = [] for hotel, ville, prix, equipements in self.hotels: if equipement in equipements: resultats.append((hotel, ville, prix, equipements)) return resultats reservation = SystemeReservation() print("Hôtels à Marrakech:") for hotel, prix, equipements in reservation.rechercher_par_ville("Marrakech"): print(f" - {hotel}: {prix[0]}-{prix[1]} DH, Équipements: {', '.join(equipements)}") print(f"\nHôtels avec piscine:") for hotel, ville, prix, equipements in reservation.rechercher_avec_equipement("piscine"): print(f" - {hotel} ({ville}): {prix[0]}-{prix[1]} DH") # 3. Système éducatif print(f"\n--- Système éducatif ---") class SystemeEducatif: def __init__(self): # (université, ville, (fondation, étudiants), [facultés]) self.universites = ( ("Université Mohammed V", "Rabat", (1957, 45000), ("Droit", "Médecine", "Sciences")), ("Université Cadi Ayyad", "Marrakech", (1978, 65000), ("Sciences", "Lettres", "Droit")), ("Université Hassan II", "Casablanca", (1975, 55000), ("Économie", "Médecine", "Ingénierie")) ) def statistiques(self): "Calcule des statistiques sur le système éducatif" total_etudiants = 0 universites_par_ville = {} facultees_uniques = set() for universite, ville, (fondation, etudiants), facultes in self.universites: total_etudiants += etudiants universites_par_ville[ville] = universites_par_ville.get(ville, 0) + 1 facultees_uniques.update(facultes) return { "total_etudiants": total_etudiants, "universites_par_ville": universites_par_ville, "nombre_facultes": len(facultees_uniques), "moyenne_etudiants": total_etudiants // len(self.universites) } def rechercher_par_faculte(self, faculte): "Trouve les universités offrant une faculté spécifique" resultats = [] for universite, ville, (fondation, etudiants), facultes in self.universites: if faculte in facultes: resultats.append((universite, ville, etudiants, fondation)) return resultats education = SystemeEducatif() stats = education.statistiques() print("Statistiques éducatives:") print(f" Total étudiants: {stats['total_etudiants']:,}".replace(",", " ")) print(f" Universités par ville: {stats['universites_par_ville']}") print(f" Nombre de facultés différentes: {stats['nombre_facultes']}") print(f" Moyenne d'étudiants par université: {stats['moyenne_etudiants']:,}".replace(",", " ")) print(f"\nUniversités avec faculté de Médecine:") for universite, ville, etudiants, fondation in education.rechercher_par_faculte("Médecine"): print(f" - {universite} ({ville}), fondée en {fondation}, {etudiants:,} étudiants".replace(",", " ")) # 4. Jeu d'échecs avec tuples imbriqués print(f"\n--- Jeu d'échecs ---") class Echiquier: def __init__(self): # Représentation de l'échiquier avec tuples imbriqués # Chaque pièce est représentée par (type, couleur) self.echiquier = ( (("tour", "noir"), ("cavalier", "noir"), ("fou", "noir"), ("reine", "noir"), ("roi", "noir"), ("fou", "noir"), ("cavalier", "noir"), ("tour", "noir")), (("pion", "noir"),) * 8, ((None, None),) * 8, ((None, None),) * 8, ((None, None),) * 8, ((None, None),) * 8, (("pion", "blanc"),) * 8, (("tour", "blanc"), ("cavalier", "blanc"), ("fou", "blanc"), ("reine", "blanc"), ("roi", "blanc"), ("fou", "blanc"), ("cavalier", "blanc"), ("tour", "blanc")) ) def afficher(self): "Affiche l'échiquier" print(" a b c d e f g h") print(" ---------------") for i, ligne in enumerate(self.echiquier): print(8-i, end=" ") for case in ligne: if case[0] is None: print(". ", end="") else: symbole = case[0][0].upper() if case[1] == "blanc" else case[0][0] print(f"{symbole} ", end="") print(8-i) print(" ---------------") print(" a b c d e f g h") def obtenir_piece(self, ligne, colonne): "Retourne la pièce à une position donnée" return self.echiquier[ligne][colonne] jeu = Echiquier() jeu.afficher() piece = jeu.obtenir_piece(0, 0) print(f"\nPièce en a8: {piece[0]} {piece[1]}") # 5. Avantages des tuples imbriqués print(f"\n--- Avantages des tuples imbriqués ---") print("✓ Immutabilité garantie") print("✓ Performance mémoire") print("✓ Hachage possible pour les clés de dictionnaire") print("✓ Structure de données prédictible") print("✓ Parfait pour les configurations et constantes")
Les tuples offrent des avantages significatifs par rapport aux listes dans des scénarios spécifiques. Leur immutabilité, leur performance et leur capacité à servir de clés de dictionnaire en font des structures de données précieuses pour de nombreuses applications.
Contrairement aux listes, les tuples peuvent être utilisés comme clés de dictionnaire car ils sont immuables et donc hachables. Cette propriété permet de créer des structures de données complexes et efficaces.
# Utilisation des tuples comme clés de dictionnaire # 1. Clés simples avec coordonnées géographiques print("--- Clés avec coordonnées ---") # Dictionnaire utilisant des tuples (latitude, longitude) comme clés villes_par_coordonnees = { (33.5731, -7.5898): "Casablanca", (34.0209, -6.8416): "Rabat", (31.6295, -7.9811): "Marrakech", (34.0333, -5.0000): "Fès" } print("Villes par coordonnées:") for coords, ville in villes_par_coordonnees.items(): print(f" {coords} → {ville}") # Recherche rapide par coordonnées coords_recherche = (31.6295, -7.9811) print(f"\nVille aux coordonnées {coords_recherche}: {villes_par_coordonnees.get(coords_recherche, 'Non trouvée')}") # 2. Clés composites pour un système de réservation print(f"\n--- Système de réservation ---") class SystemeReservation: def __init__(self): # Clé: (ville_départ, ville_arrivée, date) # Valeur: (prix, places_disponibles, compagnie) self.vols = { ("Casablanca", "Marrakech", "2024-03-15"): (450, 12, "Royal Air Maroc"), ("Rabat", "Agadir", "2024-03-16"): (520, 8, "Air Arabia"), ("Fès", "Casablanca", "2024-03-17"): (380, 15, "Royal Air Maroc"), ("Marrakech", "Tanger", "2024-03-18"): (610, 5, "Ryanair") } def rechercher_vol(self, depart, arrivee, date): cle = (depart, arrivee, date) return self.vols.get(cle) def reserver_vol(self, depart, arrivee, date, passagers=1): cle = (depart, arrivee, date) if cle in self.vols: prix, places, compagnie = self.vols[cle] if places >= passagers: # Mise à jour des places disponibles self.vols[cle] = (prix, places - passagers, compagnie) return True, f"Réservation confirmée! Total: {prix * passagers} DH" else: return False, "Places insuffisantes" return False, "Vol non trouvé" reservation = SystemeReservation() print("Recherche d'un vol:") vol = reservation.rechercher_vol("Casablanca", "Marrakech", "2024-03-15") if vol: prix, places, compagnie = vol print(f" {compagnie}: {prix} DH, {places} places") success, message = reservation.reserver_vol("Casablanca", "Marrakech", "2024-03-15", 2) print(f"\nRéservation: {message}") # 3. Cache avec tuples comme clés print(f"\n--- Système de cache ---") class CacheCalculs: def __init__(self): self.cache = {} def calculer_distance(self, ville1, ville2, unite="km"): "Calcule la distance entre deux villes avec cache" cle = (ville1, ville2, unite) # Vérifier le cache if cle in self.cache: print(f" [CACHE] Distance {ville1}-{ville2}") return self.cache[cle] # Simulation d'un calcul coûteux distances = { ("Casablanca", "Marrakech"): 240, ("Rabat", "Fès"): 200, ("Marrakech", "Agadir"): 170 } distance_base = distances.get((ville1, ville2), 0) # Conversion d'unité if unite == "miles": resultat = distance_base * 0.621371 else: resultat = distance_base # Mettre en cache self.cache[cle] = resultat print(f" [CALCUL] Distance {ville1}-{ville2}") return resultat cache_calc = CacheCalculs() print("Calculs de distances:") print(f" Casablanca-Marrakech: {cache_calc.calculer_distance('Casablanca', 'Marrakech')} km") print(f" Casablanca-Marrakech: {cache_calc.calculer_distance('Casablanca', 'Marrakech')} km") # Utilise le cache print(f" Casablanca-Marrakech: {cache_calc.calculer_distance('Casablanca', 'Marrakech', 'miles')} miles") # 4. Configuration système avec tuples imbriqués print(f"\n--- Configuration système ---") # Configuration utilisant des tuples imbriqués comme clés config_systeme = { ("database", "host"): "localhost", ("database", "port"): 5432, ("api", "timeout"): 30, ("api", "retries"): 3, ("logging", "level"): "INFO", (("security", "ssl"), "enabled"): True } print("Configuration système:") for cle, valeur in config_systeme.items(): print(f" {cle} = {valeur}") # Accès hiérarchique print(f"\nPort de la base de données: {config_systeme[('database', 'port')]}") # 5. Avantages des tuples comme clés print(f"\n--- Avantages ---") print("✓ Hachables (immuables)") print("✓ Clés composites naturelles") print("✓ Performance de recherche O(1)") print("✓ Structure de données prédictible") print("✓ Parfaits pour le caching")
Les tuples permettent aux fonctions de retourner plusieurs valeurs de manière naturelle et élégante. Cette fonctionnalité est largement utilisée dans les bibliothèques Python et les applications réelles.
# Retour multiple de valeurs avec des tuples # 1. Retour multiple basique print("--- Retour multiple basique ---") def analyser_ville(ville): "Analyse une ville et retourne plusieurs statistiques" donnees = { "Casablanca": (3359000, "économique", 33.5731, -7.5898), "Marrakech": (928850, "touristique", 31.6295, -7.9811), "Fès": (1112072, "culturel", 34.0333, -5.0000) } if ville in donnees: population, type_ville, lat, lon = donnees[ville] return population, type_ville, (lat, lon) else: return 0, "inconnu", (0, 0) # Utilisation avec déballage population, type_ville, coords = analyser_ville("Casablanca") print(f"Casablanca: {population:,} habitants, type: {type_ville}".replace(",", " ")) print(f"Coordonnées: {coords}") # 2. Retour de statuts complexes print(f"\n--- Retour de statuts ---") def traiter_commande(produit, quantite): "Traite une commande et retourne un statut détaillé" stock = { "Huile d'Argan": 50, "Tapis Berbère": 10, "Thé Marocain": 100 } prix = { "Huile d'Argan": 150.0, "Tapis Berbère": 1200.0, "Thé Marocain": 45.0 } if produit not in stock: return False, "Produit non disponible", 0, 0 if quantite > stock[produit]: return False, "Stock insuffisant", stock[produit], 0 total = quantite * prix[produit] stock[produit] -= quantite return True, "Commande traitée", quantite, total # Traitement de commandes commandes = [ ("Huile d'Argan", 2), ("Tapis Berbère", 15), # Stock insuffisant ("Produit Inexistant", 1) # Produit non disponible ] print("Traitement des commandes:") for produit, quantite in commandes: success, message, qte_traitee, total = traiter_commande(produit, quantite) statut = "✓ SUCCÈS" if success else "✗ ÉCHEC" print(f" {statut} {produit}: {message}") if success: print(f" Quantité: {qte_traitee}, Total: {total} DH") # 3. Retour pour le traitement d'erreurs print(f"\n--- Traitement d'erreurs ---") def valider_utilisateur(email, mot_de_passe): "Valide un utilisateur et retourne un tuple de statut" # Simuler une base de données utilisateurs = { "admin@maroc.ma": ("admin123", "admin", True), "client@example.com": ("pass123", "client", True), "inactif@test.ma": ("test123", "client", False) } if email not in utilisateurs: return False, "Utilisateur non trouvé", None, None mdp_stocke, role, actif = utilisateurs[email] if not actif: return False, "Compte désactivé", role, email if mdp_stocke != mot_de_passe: return False, "Mot de passe incorrect", role, email return True, "Authentification réussie", role, email # Tests d'authentification tests = [ ("admin@maroc.ma", "admin123"), ("client@example.com", "wrongpass"), ("inactif@test.ma", "test123"), ("inexistant@test.ma", "anypass") ] print("Tests d'authentification:") for email, mdp in tests: success, message, role, user_email = valider_utilisateur(email, mdp) statut = "? CONNECTÉ" if success else "? REFUSÉ" print(f" {statut} {email}: {message}") if success: print(f" Rôle: {role}") # 4. Retour pour les opérations de traitement de données print(f"\n--- Traitement de données ---") def analyser_ventes(ventes): "Analyse des ventes et retourne des statistiques complètes" if not ventes: return 0, 0, 0, 0, [] total = sum(ventes) moyenne = total / len(ventes) maximum = max(ventes) minimum = min(ventes) # Ventes au-dessus de la moyenne ventes_sup_moyenne = [v for v in ventes if v > moyenne] return total, moyenne, maximum, minimum, ventes_sup_moyenne # Analyse des ventes mensuelles ventes_trimestre = [125000, 98000, 156000, 142000] total, moyenne, maxi, mini, sup_moyenne = analyser_ventes(ventes_trimestre) print("Analyse des ventes trimestrielles:") print(f" Total: {total:,} DH".replace(",", " ")) print(f" Moyenne: {moyenne:,.0f} DH".replace(",", " ")) print(f" Maximum: {maxi:,} DH".replace(",", " ")) print(f" Minimum: {mini:,} DH".replace(",", " ")) print(f" Ventes supérieures à la moyenne: {len(sup_moyenne)}") # 5. Avantages du retour multiple print(f"\n--- Avantages ---") print("✓ Code plus lisible et concis") print("✓ Évite la création de classes simples") print("✓ Naturel pour les opérations multiples") print("✓ Compatible avec le déballage") print("✓ Standard Pythonique")
Les tuples offrent des avantages significatifs en termes de performance et de sécurité grâce à leur immutabilité. Ils sont plus rapides à traiter et garantissent l'intégrité des données.
# Performance et sécurité des tuples # 1. Comparaison de performance print("--- Comparaison de performance ---") import sys import time import timeit # Comparaison de la taille mémoire villes_liste = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"] villes_tuple = ("Casablanca", "Rabat", "Marrakech", "Fès", "Tanger") print("Comparaison de taille mémoire:") print(f" Liste: {sys.getsizeof(villes_liste)} octets") print(f" Tuple: {sys.getsizeof(villes_tuple)} octets") print(f" Économie: {sys.getsizeof(villes_liste) - sys.getsizeof(villes_tuple)} octets") # Comparaison de vitesse d'accès print(f"\nComparaison de vitesse d'accès:") # Test d'accès par index temps_liste = timeit.timeit('villes_liste[2]', globals=globals(), number=1000000) temps_tuple = timeit.timeit('villes_tuple[2]', globals=globals(), number=1000000) print(f" Accès liste: {temps_liste:.6f} secondes (1M d'opérations)") print(f" Accès tuple: {temps_tuple:.6f} secondes (1M d'opérations)") print(f" Gain: {((temps_liste - temps_tuple) / temps_liste * 100):.1f}%") # 2. Sécurité des données constantes print(f"\n--- Sécurité des données ---") class SystemeConfiguration: # Configuration immuable utilisant des tuples CONFIG_PAR_DEFAUT = ( ("database", "localhost", 5432), ("api", 30, 3), # timeout, retries ("security", True, True) # ssl, authentication ) # Constantes métier TAUX_TVA = (0.20, 0.14, 0.10) # TVA normale, réduite, super-réduite DEVISE = ("MAD", "DH") # Code, symbole def __init__(self): self.config_actuelle = self.CONFIG_PAR_DEFAUT def afficher_config(self): print("Configuration système:") for section in self.config_actuelle: print(f" {section}") def calculer_tva(self, montant, type_tva="normale"): types = {"normale": 0, "réduite": 1, "super-réduite": 2} taux = self.TAUX_TVA[types.get(type_tva, 0)] return montant * taux config = SystemeConfiguration() config.afficher_config() print(f"\nCalcul de TVA (normale): {config.calculer_tva(1000):.2f} {config.DEVISE[1]}") print(f"Calcul de TVA (réduite): {config.calculer_tva(1000, 'réduite'):.2f} {config.DEVISE[1]}") # Tentative de modification (échouera) print(f"\nTentative de modification de la configuration...") try: config.CONFIG_PAR_DEFAUT[0] = ("modified", "value") except TypeError as e: print(f" Erreur: {e}") print(" ✓ Configuration protégée contre les modifications accidentelles") # 3. Performance dans les boucles print(f"\n--- Performance dans les boucles ---") # Données de test donnees_liste = [i for i in range(10000)] donnees_tuple = tuple(i for i in range(10000)) # Test d'itération debut = time.time() for item in donnees_liste: pass temps_liste_iter = time.time() - debut debut = time.time() for item in donnees_tuple: pass temps_tuple_iter = time.time() - début print("Performance d'itération (10,000 éléments):") print(f" Liste: {temps_liste_iter:.6f} secondes") print(f" Tuple: {temps_tuple_iter:.6f} secondes") print(f" Différence: {(temps_tuple_iter - temps_liste_iter) * 1000:.2f} ms") # 4. Sécurité dans le partage de données print(f"\n--- Sécurité dans le partage ---") class SystemeAuthentification: def __init__(self): # Rôles et permissions immuables self.PERMISSIONS = ( ("admin", ("lecture", "écriture", "suppression", "administration")), ("utilisateur", ("lecture", "écriture")), ("invité", ("lecture",)) ) def verifier_permission(self, role, permission): "Vérifie si un rôle a une permission spécifique" for r, permissions in self.PERMISSIONS: if r == role: return permission in permissions return False def afficher_roles(self): print("Rôles et permissions:") for role, permissions in self.PERMISSIONS: print(f" {role}: {', '.join(permissions)}") auth = SystemeAuthentification() auth.afficher_roles() print(f"\nVérifications de permissions:") print(f" Admin peut supprimer: {auth.verifier_permission('admin', 'suppression')}") print(f" Utilisateur peut administrer: {auth.verifier_permission('utilisateur', 'administration')}") print(f" Invité peut écrire: {auth.verifier_permission('invité', 'écriture')}") # 5. Cas d'optimisation réelle print(f"\n--- Optimisation réelle ---") class AnalyseurPerformance: def __init__(self): # Données de référence immuables self.SEUILS_ALERTE = ( ("CRITIQUE", 95.0, "red"), ("ÉLEVÉ", 80.0, "orange"), ("MOYEN", 65.0, "yellow"), ("FAIBLE", 50.0, "green") ) def analyser_performance(self, utilisation_cpu): "Analyse la performance et retourne le niveau d'alerte" for niveau, seuil, couleur in self.SEUILS_ALERTE: if utilisation_cpu >= seuil: return niveau, couleur, utilisation_cpu return "NORMAL", "blue", utilisation_cpu def generer_rapport(self, *mesures): print("Rapport de performance:") for mesure in mesures: niveau, couleur, valeur = self.analyser_performance(mesure) print(f" CPU {valeur}% → {niveau} ({couleur})") performance = AnalyseurPerformance() performance.generer_rapport(45, 67, 82, 96) # 6. Résumé des avantages print(f"\n--- Résumé des avantages ---") print("? PERFORMANCE:") print(" ✓ Allocation mémoire plus efficace") print(" ✓ Accès plus rapide aux éléments") print(" ✓ Meilleure performance en itération") print(" ✓ Optimisation du cache processeur") print(f"\n? SÉCURITÉ:") print(" ✓ Données protégées contre les modifications") print(" ✓ Intégrité des constantes garantie") print(" ✓ Partage sécurisé entre threads") print(" ✓ Prévention des bugs liés aux mutations") print(f"\n? UTILISATION RECOMMANDÉE:") print(" ✓ Données constantes et configurations") print(" ✓ Clés de dictionnaire") print(" ✓ Retour multiple de fonctions") print(" ✓ Données en lecture seule") print(" ✓ Structures de données immuables")
Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.
Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!